Soft real-time garbage collection for dynamic dispatch languages

Common to many high-level, declarative and object oriented languages are the use of dynamic dispatch and garbage collection. Dynamic dispatch is the mechanism by which the selection of a method to run, based on both its signature, and the type of one or more of its arguments, is made. A garbage collector is responsible for efficient ‘recycling’ of memory that is no longer needed, termed ‘garbage’, via a process of automatic deallocation that returns the memory to the program’s allocation area. In this work we investigate various schemes for the efficient implementation of soft real-time multi-generation garbage collection algorithms within dynamic dispatch languages. Our focus is on techniques that reduce and eliminate the synchronisation costs between interleaved user program and collector execution. Furthermore, we work to bound the amount of time for which the user program is paused, while the collector runs, so that real-time constraints can be met. This dissertation describes the implementation of a production uniprocessor collector for Haskell, and evaluates its performance against implementations of existing algorithms. An important focus of our analysis is the effect that the various memory overheads of each scheme have on the performance of the collector. Our experiments demonstrate that closure code specialisation improves performance when it is used to remove dynamic space overheads. A 30% code bloat on top of the baseline generational collector buys us a time-based incremental generational collector whose mutator overhead is 5% when averaged across the nofib benchmark suite. Furthermore, not only does the collector achieve a consistent minimum mutator utilisation of 50% at around 10 to 15 milliseconds, but results, on average, in a performance increase of around 5% at the expense of a small additional amount of memory. The remainder of the dissertation explores the applicability of our collector to other dynamic dispatch languages with a prototype implementation for Java.